<h1 id="-">第十章</h1>
<hr>
<h2 id="blocks-procs-and-lambdas">Blocks, Procs and Lambdas</h2>
<p>当程序员谈论“块”（Block）时，它们通常意味着一些独立的“代码块”（chunks）。但是，在 Ruby 中一个 block 是特殊的。它是一个代码单元，有点像方法，但与方法不同的是它没有名称。为了有效的使用 block，您需要了解它们的特殊性和原因。这就是本章的全部内容...</p>
<h3 id="-block-">什么是 Block？</h3>
<p>思考这些代码：</p>
<div class="code-file clearfix"><span>1blocks.rb</span></div>

<pre><code><span class="hljs-number">3.</span>times <span class="hljs-built_in">do</span> |<span class="hljs-type">i</span>|
  <span class="hljs-type">puts</span>( i )
<span class="hljs-keyword">end</span></code></pre><p>很明显，这段代码实际上会执行三次。在每次连续的循环中 <code>i</code> 的值可能不是那么的明显。实际上，在这种情况下，<code>i</code> 的值将为 0,1 和 2。这是上面代码的另一种形式。这一次，block 由花括号限定，而不是由 <code>do</code> 和 <code>end</code>：</p>
<pre><code><span class="hljs-number">3.</span>times { |<span class="hljs-type">i</span>|
  <span class="hljs-type">puts</span>( i )
}</code></pre><p>根据 Ruby 文档，<code>times</code> 是 Integer 类的一个方法（让我们称 Integer 为 <code>int</code>），它迭代一个块 <code>int</code> 次，并且传入从 0 到 <code>int</code> -1 的值&#39;。所以，这里 block 中的代码运行 3 次；第一次运行时，变量 <code>i</code> 其值为 0；在后序循环中，<code>i</code> 将增加 1 直到达到最终值 2（即 <code>int</code>-1）。</p>
<p>请注意，上面的两个代码示例在功能上是相同的。Block 可以用花括号或 <code>do</code> 和 <code>end</code> 关键字括起来，程序员可以根据个人喜好使用任一语法。</p>
<div class="note">

<p><strong>注意：</strong>一些 Ruby 程序员喜欢在当块的整个代码只有单行时用花括号来限定，而当块跨越多行时使用 <code>do..end</code>。我个人的意见是要统一，不管代码布局如何，我通常在分隔块时都使用花括号。通常，你选择的限定符对代码的行为没有任何影响 - 但请参阅本章后面有关“优先级规则”（precedence rules）的部分。</p>
</div>

<p>如果你熟悉类似 C 的语言（如 C# 或 Java），你应该会使用 Ruby 的花括号，就像在这些语言中一样，只需将独立的“块”（blocks）代码组合在一起 - 例如，条件计算结果为 true 时要执行的代码块。但情况并非如此。在 Ruby 中，块是一种特殊的结构，只能在非常特殊的情况下使用。</p>
<h3 id="-">换行值得注意</h3>
<p>Block 的开（opening）限定符必须与其关联的方法放在同一行。</p>
<p>这些是可以的...</p>
<pre><code><span class="hljs-number">3.</span>times <span class="hljs-built_in">do</span> |<span class="hljs-type">i</span>|
  <span class="hljs-type">puts</span>( i )
<span class="hljs-keyword">end</span>

<span class="hljs-number">3.</span>times { |<span class="hljs-type">i</span>|
  <span class="hljs-type">puts</span>( i )
}</code></pre><p>但这些包含了语法错误...</p>
<pre><code><span class="hljs-number">3.</span>times
<span class="hljs-built_in">do</span> |<span class="hljs-type">i</span>|
  <span class="hljs-type">puts</span>( i )
<span class="hljs-keyword">end</span>

<span class="hljs-number">3.</span>times
{ |<span class="hljs-type">i</span>|
  <span class="hljs-type">puts</span>( i )
}</code></pre><h3 id="-">匿名函数</h3>
<p>Ruby 的 block 可以被视为一种匿名函数（nameless function）或方法（method），并且其最常用于提供迭代列表项或范围值的一种方式。如果你之前从未遇到过匿名函数，这可能听起来像官方话（gobbledygook）。幸运的是，到本章结束时，事情会变得更加清晰。让我们回顾一下前面给出的简单示例。我说一个 block 就像一个匿名函数。以此块为例：</p>
<pre><code>{ |i|
  puts( i )
}</code></pre><p>如果它作为普通的 Ruby 方法来编写，它看起来可能像这样：</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">aMethod</span><span class="hljs-params">( i )</span></span>
  puts( i )
<span class="hljs-keyword">end</span></code></pre><p>要调用该方法三次并将从 0 到 2 的值传递给它，我们可能会这样写：</p>
<pre><code><span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-number">0.</span><span class="hljs-number">.2</span>
  aMethod( i )
end</code></pre><p>当你创建一个匿名方法（即 block），在竖线之间声明的变量（例如 <code>|i|</code>）可以像命名方法的参数一样对待。我们将这些变量称为“块参数”（block parameters）。</p>
<p>再看看我之前的示例：</p>
<pre><code><span class="hljs-number">3.</span>times { |<span class="hljs-type">i</span>|
  <span class="hljs-type">puts</span>( i )
}</code></pre><p>整数的 <code>times</code> 方法将从 0 到具体整数值减去 1 的值传递给块。</p>
<p>所以：</p>
<pre><code>3.times{ |<span class="hljs-string">i</span>|<span class="hljs-string"> }</span></code></pre><p>...非常像：</p>
<pre><code><span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-number">0.</span><span class="hljs-number">.2</span>
  aMethod( i )
end</code></pre><p>主要区别在于第二个示例必须调用其它一些命名方法来处理 <code>i</code> 的值，而第一个示例使用匿名方法（花括号之间的代码）来处理 <code>i</code>。</p>
<h3 id="-">看起来眼熟？</h3>
<p>既然你现在知道 Block 是什么了，你可能会注意到你之前见过它们很多次。</p>
<p>例如，我们之前使用 <code>do..end</code> 块来迭代范围（ranges）：</p>
<pre><code>(<span class="hljs-number">1.</span><span class="hljs-number">.3</span>).each <span class="hljs-built_in">do</span> |<span class="hljs-type">i</span>|
  <span class="hljs-type">puts</span>(i)
<span class="hljs-keyword">end</span></code></pre><p>我们还使用了 <code>do..end</code> 块来迭代数组（参见第 5 章中的 <strong>for_each2.rb</strong>）：</p>
<pre><code>arr = [<span class="hljs-string">'one'</span>,<span class="hljs-string">'two'</span>,<span class="hljs-string">'three'</span>,<span class="hljs-string">'four'</span>]
arr.each <span class="hljs-keyword">do</span> <span class="hljs-params">|s|</span>
  puts(s)
<span class="hljs-keyword">end</span></code></pre><p>我们通过将它传递给 <code>loop</code> 方法来重复执行一个 block（参见第 5 章中的 <strong>3loops.rb</strong>）：</p>
<pre><code><span class="hljs-built_in">i</span>=<span class="hljs-number">0</span>
loop {
  puts(arr[<span class="hljs-built_in">i</span>])
  <span class="hljs-built_in">i</span>+=<span class="hljs-number">1</span>
  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">i</span> == arr.<span class="hljs-built_in">length</span>) then
    <span class="hljs-keyword">break</span>
  <span class="hljs-keyword">end</span>
}</code></pre><p>上面的 <code>loop</code> 示例在两方面是很明显的：1）它没有要迭代的项目列表（例如数组或范围值）；2）它非常难看。这两个特点并非完全不相关！<code>loop</code> 方法是 Kernel 类的一部分，它可以“直接”（automatically）用于你的程序。由于它没有&#39;结束值&#39;（end value），它将永远执行该 block，除非你明确地使用 <code>break</code> 关键字中断它。通常有更优雅的方式来执行这种迭代 - 通过迭代一系列有限范围的值。</p>
<h3 id="-">块和数组</h3>
<p>块（Blocks）通常用于迭代数组（Array）。 因此，Array 类提供了许多可以传递块的方法。</p>
<p>一个有用的方法 <code>collect</code>；会将数组的每个元素传递给一个 block，并创建一个新数组以包含该 block 返回的每个值。例如，这里的一个 block 会被传入一个数组中的每个整数（每个整数被分配给变量 <code>x</code>），它将其值加倍并返回它。</p>
<p><code>collect</code> 方法会创建一个包含了每个按顺序返回的整数的新数组：</p>
<div class="code-file clearfix"><span>2blocks.rb</span></div>

<pre><code>b3 = [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>].collect{|x| x*<span class="hljs-number">2</span>}</code></pre><p>上面的示例返回这个数组：<code>[2,4,6]</code>。</p>
<p>在下一个示例中，block 返回原始字符串每个首字母大写的一个版本：</p>
<pre><code>b4 = [<span class="hljs-string">"hello"</span>,<span class="hljs-string">"good day"</span>,<span class="hljs-string">"how do you do"</span>].collect{|<span class="hljs-type">x</span>| <span class="hljs-type">x</span>.capitalize }</code></pre><p>所以 <code>b4</code> 现在是...</p>
<pre><code>[<span class="hljs-string">"Hello"</span>, <span class="hljs-string">"Good day"</span>, <span class="hljs-string">"How do you do"</span>]</code></pre><p>Array 类的 <code>each</code> 方法看起来与 <code>collect</code> 类似；它也依次传递每个数组元素以由 block 处理。但是，与 <code>collect</code> 不同，<code>each</code> 方法不会创建包含返回值的新数组：</p>
<pre><code>b5 = [<span class="hljs-string">"hello"</span>,<span class="hljs-string">"good day"</span>,<span class="hljs-string">"how do you do"</span>].each{|<span class="hljs-type">x</span>| <span class="hljs-type">x</span>.capitalize }</code></pre><p>这一次，<code>b5</code> 没有变化...</p>
<pre><code>[<span class="hljs-string">"hello"</span>, <span class="hljs-string">"good day"</span>, <span class="hljs-string">"how do you do"</span>]</code></pre><p>回想一下，有些方法 - 特别是以感叹号（<code>!</code>）结尾的方法 - 实际上改变了原始对象而不是产生新值。如果你想使用 <code>each</code> 方法来将原始数组中的字符串首字母大写，你可以使用 <code>capitalize!</code> 方法：</p>
<pre><code>b6 = [<span class="hljs-string">"hello"</span>,<span class="hljs-string">"good day"</span>,<span class="hljs-string">"how do you do"</span>].each{|<span class="hljs-type">x</span>| <span class="hljs-type">x</span>.capitalize! }</code></pre><p>所以 <code>b6</code> 现在是...</p>
<pre><code>[<span class="hljs-string">"Hello"</span>, <span class="hljs-string">"Good day"</span>, <span class="hljs-string">"How do you do"</span>]</code></pre><p>经过一番思考，你还可以使用 block 来迭代字符串中的字符（characters）。首先，你需要从字符串中拆分每个字符。这可以使用 String 类的 <code>split</code> 方法完成，如下所示：</p>
<pre><code><span class="hljs-string">"hello world"</span>.<span class="hljs-built_in">split</span><span class="hljs-comment">(//)</span></code></pre><p><code>split</code> 方法基于分隔符将字符串划分为子字符串，并返回包含这些子字符串的数组。这里 <code>//</code> 是一个定义零长度字符串的正则表达式；这具有返回单个字符的效果，因此我们最终创建了包含字符串中所有字符的数组。我们现在可以迭代这个字符数组，返回每个字符的大写版本：</p>
<pre><code>a = <span class="hljs-string">"hello world"</span>.<span class="hljs-built_in">split</span>(//).each{ |<span class="hljs-type">x</span>| <span class="hljs-type">newstr</span> &lt;&lt; x.capitalize }</code></pre><p>因此，在每次迭代时，大写字符将附加到 <code>newstr</code>，并显示以下内容...</p>
<pre><code><span class="hljs-attr">H</span>
<span class="hljs-attr">HE</span>
<span class="hljs-attr">HEL</span>
<span class="hljs-attr">HELL</span>
<span class="hljs-attr">HELLO</span>
<span class="hljs-attr">HELLO</span>
<span class="hljs-attr">HELLO</span> <span class="hljs-string">W</span>
<span class="hljs-attr">HELLO</span> <span class="hljs-string">WO</span>
<span class="hljs-attr">HELLO</span> <span class="hljs-string">WOR</span>
<span class="hljs-attr">HELLO</span> <span class="hljs-string">WORL</span>
<span class="hljs-attr">HELLO</span> <span class="hljs-string">WORLD</span></code></pre><p>因为我们在这里使用 <code>capitalize</code> 方法（结尾没有 <code>!</code> 字符），所以数组中的字符 <code>a</code> 保持原样，全部小写，因为 <code>capitalize</code> 方法不会改变接收对象（这里接收对象是传入 block 的字符）。</p>
<p>但请注意，如果你使用 <code>capitalize!</code> 方法修改原始字符，此代码将不会运行。这是因为 <code>capitalize!</code> 如果没有进行任何更改则会返回 <code>nil</code>，因此当遇到空格字符时，将返回 <code>nil</code>，并且我们尝试向字符串 <code>newstr</code> 追加（<code>&lt;&lt;</code>）一个 <code>nil</code> 值将会失败。</p>
<p>你还可以使用 <code>each_byte</code> 方法对字符串进行首字母大写转换。这将遍历字符串的字符，将每个字节（byte）传递给 block。这些字节采用了 ASCII 码的形式。因此，&quot;hello world&quot; 将以这些数值的形式传递：<code>104</code> <code>101</code> <code>108</code> <code>108</code> <code>111</code> <code>32</code> <code>119</code> <code>111</code> <code>114</code> <code>108</code> <code>100</code></p>
<p>显然，你不能将整数大写，所以我们需要将每个 ASCII 值转换为一个字符。String 的 <code>chr</code> 方法执行此操作：</p>
<pre><code>a = <span class="hljs-string">"hello world"</span>.each_byte{|<span class="hljs-symbol">x</span>| newstr &lt;&lt; (<span class="hljs-symbol">x</span>.<span class="hljs-built_in">chr</span>).capitalize }</code></pre><h3 id="procs-lambdas">Procs 与  Lambdas</h3>
<p>到目前为止，在我们的示例中块（blocks）都和方法（methods）一起使用。这是必须的，因为匿名块在 Ruby 中不能独立存在。例如，你不能像这样创建一个独立的块：</p>
<pre><code>{|<span class="hljs-meta">x</span>| <span class="hljs-meta">x</span> = <span class="hljs-meta">x</span><span class="hljs-comment">*10;</span> puts(<span class="hljs-meta">x</span>)}</code></pre><p>这是&quot;Ruby中的所有内容都是对象&quot;这一规则的例外情况之一。块显然不是一个对象。每个对象都是从类创建的，你可以通过调用其 <code>class</code> 方法来查找对象的类。</p>
<p>例如，使用 Hash 对象执行此操作，会显示类名 &quot;Hash&quot;：</p>
<pre><code><span class="hljs-function"><span class="hljs-title">puts</span><span class="hljs-params">({<span class="hljs-number">1</span>=&gt;<span class="hljs-number">2</span>}.class)</span></span></code></pre><p>但是，尝试对块执行此操作，你只会得到一条错误消息：</p>
<pre><code>puts({|i| puts(<span class="hljs-name">i</span>)}.class) #&lt;= error!</code></pre><div class="note">
    <p class="h4"><b>Block 还是 Hash？</b></p>

<p>Ruby 使用花括号来限定 block 和 Hash。那你（以及 Ruby）怎么能分辨哪个是哪个？答案基本上就是当它看起来像 Hash 时它是 Hash，否则它就是一个 block。Hash 看起来是在花括号中包含了键值（key-value）对...</p>
<pre><code><span class="hljs-function"><span class="hljs-title">puts</span><span class="hljs-params">( {<span class="hljs-number">1</span>=&gt;<span class="hljs-number">2</span>}.class )</span></span> #&lt;= Hash</code></pre><p>...或者，当它们是空（empty）的：</p>
<pre><code><span class="hljs-function"><span class="hljs-title">puts</span><span class="hljs-params">( {}.class )</span></span> #&lt;= Hash</code></pre><p>但是，又一次的，当你省略括号时，将会出现歧义。这是一个空的 Hash 还是与 <code>puts</code> 方法相关联的一个 block？</p>
<pre><code><span class="hljs-selector-tag">puts</span>{}<span class="hljs-selector-class">.class</span></code></pre><p>坦率地说，我不得不承认我不知道这个问题的答案，我也无法让 Ruby 告诉我。Ruby 认为这是有效的语法，但事实上，在代码执行时不会显示任何内容。所以，这个...</p>
<pre><code><span class="hljs-keyword">print</span>{}.<span class="hljs-keyword">class</span></code></pre><p>...打印为 <code>nil</code>（你不会注意到实际的 <code>nil</code> 类，即 Nil-Class，而是 <code>nil</code> 本身）。如果你发现所有的这些令人困惑（就像我一样！），请记住，通过明确地使用括号可以避免这一点：</p>
<pre><code>print( {}.<span class="hljs-keyword">class</span> ) <span class="hljs-comment">#&lt;= Hash</span></code></pre></div>

<h3 id="-">创建块对象</h3>
<div class="code-file clearfix"><span>proc_create.rb</span></div>

<p>虽然默认情况下块（blocks）可能不是对象，但它们可以&quot;变成&quot;对象。有三种方式可以创建块对象并将它们分配给变量 - 具体方法如下：</p>
<pre><code>a = Proc.new{|<span class="hljs-meta">x</span>| <span class="hljs-meta">x</span> = <span class="hljs-meta">x</span><span class="hljs-comment">*10;</span> puts(<span class="hljs-meta">x</span>) }
b = lambda{|<span class="hljs-meta">x</span>| <span class="hljs-meta">x</span> = <span class="hljs-meta">x</span><span class="hljs-comment">*10;</span> puts(<span class="hljs-meta">x</span>) }
c = proc{|<span class="hljs-meta">x</span>| <span class="hljs-meta">x</span>.capitalize! }</code></pre><p>请注意，在上述三种情况下，你最终都会创建一个 Proc 类的实例 - 这是 Ruby 为块提供的&#39;对象包装器&#39;（object wrapper）。让我们仔细看看创建 Proc 对象的三种方法。首先，你可以调用 <code>Proc.new</code> 创建一个对象，并将块作为参数传递给它：</p>
<div class="code-file clearfix"><span>3blocks.rb</span></div>

<pre><code>a = Proc.new{|<span class="hljs-meta">x</span>| <span class="hljs-meta">x</span> = <span class="hljs-meta">x</span><span class="hljs-comment">*10;</span> puts(<span class="hljs-meta">x</span>)}</code></pre><p>你可以通过 <code>a</code> 引用使用 Proc 类的 <code>call</code> 方法执行块中的代码，并将一个或多个参数（匹配块参数）传递给块；在上面的代码中，你可以传递一个整数，如 100，这将被分配给块变量 <code>x</code>：</p>
<pre><code><span class="hljs-selector-tag">a</span>.call(<span class="hljs-number">100</span>)</code></pre><p>你也可以通过调用 <code>lambda</code> 或 <code>proc</code> 方法来创建 Proc 对象。这些方法（由 Kernel 类提供）是相同的。名称 <code>lambda</code> 取自 Scheme（Lisp）语言，是用于描述匿名方法或“闭包”（closure）的术语。</p>
<p>使用 <code>Proc.new</code> 创建 Proc 对象和使用 <code>proc</code> 或 <code>lambda</code> 方法创建 Proc 对象之间有一个重要的区别 - <code>Proc.new</code> 不检查传递给块的数字或参数是否与块参数的数量匹配 - 但 <code>proc</code> 和 <code>lambda</code> 会做检查：</p>
<div class="code-file clearfix"><span>proc_lamba.rb</span></div>

<pre><code>a = Proc.new{|<span class="hljs-meta">x</span>,y,z| <span class="hljs-meta">x</span> = y<span class="hljs-comment">*z;</span> puts(<span class="hljs-meta">x</span>) }
a.<span class="hljs-meta">call</span>(2,5,10,100) # This is <span class="hljs-meta">not</span> an <span class="hljs-meta">error</span>

b = lambda{|<span class="hljs-meta">x</span>,y,z| <span class="hljs-meta">x</span> = y<span class="hljs-comment">*z;</span> puts(<span class="hljs-meta">x</span>) }
b.<span class="hljs-meta">call</span>(2,5,10,100) # This is an <span class="hljs-meta">error</span>

puts(<span class="hljs-string">'---Block #2---'</span> )
c = proc{|<span class="hljs-meta">x</span>,y,z| <span class="hljs-meta">x</span> = y<span class="hljs-comment">*z;</span> puts(<span class="hljs-meta">x</span>) }
c.<span class="hljs-meta">call</span>(2,5,10,100) # This is an <span class="hljs-meta">error</span></code></pre><div class="code-file clearfix"><span>block_closure.rb</span></div>

<h3 id="-">什么是闭包？</h3>
<p>&#39;闭包&#39;（Closure）是一类函数的名称，这些函数能够在创建块的作用域（将其视为块的“原作用域”，native scope）内存储（即“封闭”，enclose）局部变量的值。Ruby 的块是闭包。要理解这一点，请看这个示例：</p>
<pre><code><span class="hljs-variable">x</span> = <span class="hljs-string">"hello world"</span>

<span class="hljs-variable">ablock</span> = <span class="hljs-variable">Proc</span>.new { <span class="hljs-function"><span class="hljs-title">puts</span>( <span class="hljs-variable">x</span> ) }

<span class="hljs-variable">def</span> <span class="hljs-title">aMethod</span>( <span class="hljs-variable">aBlockArg</span> )</span>
  <span class="hljs-variable">x</span> = <span class="hljs-string">"goodbye"</span>
  <span class="hljs-variable">aBlockArg</span>.call
<span class="hljs-variable">end</span>

<span class="hljs-function"><span class="hljs-title">puts</span>( <span class="hljs-variable">x</span> )</span>
<span class="hljs-variable">ablock</span>.call
<span class="hljs-function"><span class="hljs-title">aMethod</span>( <span class="hljs-variable">ablock</span> )</span>
<span class="hljs-variable">ablock</span>.call
<span class="hljs-function"><span class="hljs-title">puts</span>( <span class="hljs-variable">x</span> )</span></code></pre><p>这里，在 <code>ablock</code> 作用域的内局部变量 <code>x</code> 的值是 &quot;hello world&quot;。但是，在 <code>aMethod</code> 方法中，名为 <code>x</code> 的局部变量具有值，&#39;goodbye&#39;。尽管如此，当 <code>ablock</code> 被传递给 <code>aMethod</code> 并在 <code>aMethod</code> 的作用域内调用时，它打印出 &quot;hello world&quot;（即，在块的 &#39;native scope&#39; 中 <code>x</code> 的值，而不是在 <code>aMethod</code> 的作用域内 <code>x</code> 的值 &#39;goodbye&#39;）。</p>
<div class="note">

<p>有关闭包（closures）的更多信息，请参阅本章末尾的<strong>“深入探索”</strong>。</p>
</div>

<h3 id="yield">Yield</h3>
<p>让我们看看还有更多在使用中的块。<strong>4blocks.rb</strong> 程序引入了一些新东西 - 即一种执行传递给方法的匿名块的方式。这是使用关键字 <code>yield</code> 完成的。在第一个示例中，我定义了这个简单的方法：</p>
<div class="code-file clearfix"><span>4blocks.rb</span></div>

<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">aMethod</span></span>
  <span class="hljs-keyword">yield</span>
<span class="hljs-keyword">end</span></code></pre><p>它实际上没有任何自己的代码。相反，它期望接收一个块并且 <code>yield</code> 关键字会让块执行。这是我传递一个块的方式：</p>
<pre><code>aMethod{ <span class="hljs-built_in">puts</span>( <span class="hljs-string">"Good morning"</span> ) }</code></pre><p>请注意，这次块不作为命名参数传递。尝试在圆括号之间传递块是错误的，如下所示：</p>
<pre><code>aMethod( { puts( <span class="hljs-string">"Good morning"</span> ) } ) # This won't work!</code></pre><p>相反，我们只是将块放在我们传递它的方法右侧旁边，就像我们在本章的第一个示例中所做的那样。该方法接收没有声明命名参数的块，并用 <code>yield</code> 调用块。</p>
<p>这是一个稍微有用的示例：</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">caps</span><span class="hljs-params">( anarg )</span></span>
  <span class="hljs-keyword">yield</span>( anarg )
<span class="hljs-keyword">end</span>

caps( <span class="hljs-string">"a lowercase string"</span> ){ <span class="hljs-params">|x|</span> x.capitalize! ; puts( x ) }</code></pre><p>这里 <code>caps</code> 方法接收一个参数 <code>anarg</code>，并将此参数传递给匿名块，然后由 <code>yield</code> 执行。当我调用 <code>caps</code> 方法时，我使用通常的参数传递语法传递一个字符串参数（&quot;a lowercase string&quot;）。匿名块在参数列表<em>之后</em>传递。当 caps 方法用字符串参数调用 <code>yield(anarg)</code> 时，&quot;a lowercase string&quot; 会被传递给该块，它被分配给块变量 <code>x</code>，它将其首字母大写并用 <code>puts(s)</code> 显示它。</p>
<h3 id="-">块之中的块</h3>
<p>我们已经看到了如何使用块来迭代数组。在下一个示例中，我使用一个块来迭代一个字符串数组，依次将每个字符串分配给块变量 <code>s</code>。然后将第二个块传递给 <code>caps</code> 方法，以便将字符串的首字母大写：</p>
<pre><code>[<span class="hljs-string">"hello"</span>,<span class="hljs-string">"good day"</span>,<span class="hljs-string">"how do you do"</span>].each{
  |<span class="hljs-type">s</span>|
  <span class="hljs-type">caps</span>( s ){ |<span class="hljs-type">x</span>| <span class="hljs-type">x</span>.capitalize!
    puts( x )
  }
}</code></pre><p>输出结果：</p>
<pre><code>Hello
Good <span class="hljs-built_in">day</span>
How <span class="hljs-keyword">do</span> you <span class="hljs-keyword">do</span></code></pre><h3 id="-proc-">传递命名的 Proc 参数</h3>
<p>到目前为止，我们已经通过匿名的（在这种情况下使用 <code>yield</code> 关键字执行块）或以命名参数的形式将块传递给例程（procedures），在这种情况下，它使用 <code>call</code> 方法执行。 还有另一种传递块的方法。当方法的参数列表中的最后一个参数前面有一个 <code>＆</code> 符号时，它被认为是一个 Proc 对象。这使你可以选择使用与将块传递给迭代器时相同的语法将匿名块传递给例程。然而，例程本身可以接收块作为命名参数。运行 <strong>5blocks.rb</strong> 以查看此示例。</p>
<div class="code-file clearfix"><span>5blocks.rb</span></div>

<p>首先，这里提醒我们已经看到过传递块的两种方式。 该方法有三个参数，a，b，c：</p>
<pre><code>def abc( a, b, <span class="hljs-keyword">c</span> )
  a.<span class="hljs-keyword">call</span>
  b.<span class="hljs-keyword">call</span>
  <span class="hljs-keyword">c</span>.<span class="hljs-keyword">call</span>
  yield
<span class="hljs-keyword">end</span></code></pre><p>我们用三个命名参数调用这个方法（这里恰好是块，但原则上可以是任何东西）加上一个未命名的块：</p>
<pre><code><span class="hljs-function"><span class="hljs-title">abc</span><span class="hljs-params">(a, b, c )</span></span>{ puts <span class="hljs-string">"four"</span> }</code></pre><p><code>abc</code> 方法使用 <code>call</code> 方法执行命名的块参数，使用 <code>yield</code> 关键字执行未命名的块：</p>
<pre><code><span class="hljs-selector-tag">a</span><span class="hljs-selector-class">.call</span>  #&lt;= call block <span class="hljs-selector-tag">a</span>
<span class="hljs-selector-tag">b</span><span class="hljs-selector-class">.call</span>  #&lt;= call block <span class="hljs-selector-tag">b</span>
c<span class="hljs-selector-class">.call</span>  #&lt;= call block c
yield  #&lt;= yield unnamed block: { puts <span class="hljs-string">"four"</span> }</code></pre><p>下一个方法 <code>abc2</code> 接收单个参数，<code>＆d</code>：</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">abc2</span><span class="hljs-params">( &amp;d )</span></span></code></pre><p>此处的 ＆ 符是重要的，因为它表示 <code>＆d</code> 参数是一个块。但是，我们不需要将此块作为命名参数发送。相反，我们只需将其附加到方法名称后即可传递未命名的块：</p>
<pre><code>abc2{ <span class="hljs-built_in">puts</span> <span class="hljs-string">"four"</span> }</code></pre><p><code>abc2</code> 方法不使用 <code>yield</code> 关键字，而是使用参数名称（没有 ＆ 符号）执行块：</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">abc2</span><span class="hljs-params">( &amp;d )</span></span>
  d.call
<span class="hljs-keyword">end</span></code></pre><p>你可以将 ＆ 符号参数视为块参数的类型检查（type-checked）。也就是说，＆ 参数被正式声明，因此与匿名块（那些 &#39;yielded&#39;）不同，块不会在&#39;未通知&#39;（unannounced）的情况下到达方法。但与普通参数（没有 ＆ 符号）不同，它们必须匹配块。你不能将其它类型的对象传递给 <code>abc2</code>：</p>
<pre><code>abc2(<span class="hljs-number"> 10 </span>) <span class="hljs-comment"># This won‟t work!</span></code></pre><p>除了指定第四个正式参数 <code>(＆d)</code> 之外，<code>abc3</code> 方法与 <code>abc</code> 方法基本相同：</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">abc3</span><span class="hljs-params">( a, b, c, &amp;d)</span></span></code></pre><p>参数 <code>a</code>，<code>b</code> 和 <code>c</code> 被调用，而参数 <code>＆d</code> 可以被调用（call）或产生（yield），如你所愿：</p>
<pre><code>def abc3( a, b, c, <span class="hljs-variable">&amp;d</span>)
  a.<span class="hljs-meta">call</span>
  b.<span class="hljs-meta">call</span>
  c.<span class="hljs-meta">call</span>
  d.<span class="hljs-meta">call</span> #&lt;= block <span class="hljs-variable">&amp;d</span>
  yield #&lt;= also block <span class="hljs-variable">&amp;d</span>
<span class="hljs-meta">end</span></code></pre><p>这意味着调用代码必须将三个普通参数和一个块（这可能是匿名的）传递给此方法：</p>
<pre><code><span class="hljs-function"><span class="hljs-title">abc3</span><span class="hljs-params">(a, b, c)</span></span>{ puts <span class="hljs-string">"five"</span> }</code></pre><p>当接收方法没有匹配的命名参数时，你还可以使用前缀 ＆ 符号将命名块传递给方法，如下所示：</p>
<pre><code>abc3(<span class="hljs-name">a</span>, b, c, <span class="hljs-symbol">&amp;myproc</span> )</code></pre><p>当一个 ＆ 符号块变量传递给一个方法时（如上面的代码所示），它可能会被生成（yielded）。这提供了传递匿名块或 Proc 对象的选项：</p>
<pre><code>xyz{ |a,b,c| puts<span class="hljs-comment">(a+b+c)</span> }
xyz<span class="hljs-comment">( &amp;myproc )</span></code></pre><p>但要小心！请注意，在上面的一个示例中，我使用了块参数（<code>|a, b, c|</code>），其名称与我之前分配给 Proc 对象的三个局部变量的名称相同：<code>a</code>，<code>b</code>，<code>c</code>：</p>
<pre><code>a = lambda{ puts <span class="hljs-string">"one"</span> }
b = lambda{ puts <span class="hljs-string">"two"</span> }
c = proc{ puts <span class="hljs-string">"three"</span> }

xyz{ |a,b,c| puts(a+b+c) }</code></pre><p>现在，原则上块参数应仅在块本身内可见。但是，事实证明，对块参数的赋值可以初始化在块的原作用域（native scope，请参阅本章前面的“什么是闭包？”）内具有与块参数相同名称的任何局部变量的值。</p>
<p>尽管 <code>xyz</code> 方法中的变量被命名为 <code>x</code>，<code>y</code> 和 <code>z</code>，但事实证明，该方法中的整数赋值实际上是对块中变量 <code>a</code>，<code>b</code> 和 <code>c</code> 进行的。</p>
<pre><code>{ |a,b,c| puts(<span class="hljs-name">a+b+c</span>) }</code></pre><p>...传递 <code>x</code>，<code>y</code> 和 <code>z</code> 的值：</p>
<pre><code>def xyz
  x = <span class="hljs-number">1</span>
  y = <span class="hljs-number">2</span>
  z = <span class="hljs-number">3</span>
  yield( x, y, z ) # <span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span> assigned to block parameters a,b,c
end</code></pre><p>因此，一旦块中的代码运行，块的原作用域（native scope，也是我的程序的 main 作用域）中的变量 <code>a</code>，<code>b</code> 和 <code>c</code> 就会被块变量的值初始化：</p>
<pre><code>xyz{ |a,b,c| puts<span class="hljs-comment">(a+b+c)</span> }
puts<span class="hljs-comment">( a, b, c )</span> <span class="hljs-attr"># displays 1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span></code></pre><p>为了更清楚这一点，请尝试 <strong>6blocks.rb</strong> 中的简单程序：</p>
<div class="code-file clearfix"><span>6blocks.rb</span></div>

<pre><code>a = <span class="hljs-string">"hello world"</span>

<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">foo</span></span>
  <span class="hljs-keyword">yield</span> <span class="hljs-number">100</span>
<span class="hljs-keyword">end</span>

puts( a )
foo{ <span class="hljs-params">|a|</span> puts( a ) }

puts( a ) <span class="hljs-comment">#&lt; a is now 100</span></code></pre><p>这是一个容易陷入 Ruby 的陷阱之一的例子。作为一般规则，当变量共享相同的作用域（例如，在此处程序的 main 作用域内声明的块）时，最好使其名称唯一，以避免任何不可预见的副作用。</p>
<p>请注意，此处描述的块作用域适用于 Ruby 1.8.x 以上的版本（包含此版本），在编写本文时，它可能被认为是 Ruby 的“标准”（standard）版本。Ruby 1.9 中正在对作用域进行更改，并将其合并到 Ruby 2.0 中。有关作用域的更多信息，请参阅本章末尾的“深入探索”部分中的“块和局部变量”。</p>
<h3 id="-">优先级规则</h3>
<p>花括号内的块比 <code>do</code> 和 <code>end</code> 中的块具有更高的优先级（precedence）。让我们看看这在实践中意味着什么。思考这两个例子：</p>
<pre><code>foo bar <span class="hljs-built_in">do</span> |<span class="hljs-type">s</span>| <span class="hljs-type">puts</span>( s ) <span class="hljs-keyword">end</span>
foo bar{ |<span class="hljs-type">s</span>| <span class="hljs-type">puts</span>(s) }</code></pre><p>这里，<code>foo</code> 和 <code>bar</code> 是方法。那么块传递给哪个方法？事实证明，<code>do..end</code> 块将被传递给最左边的方法 <code>foo</code>，而花括号中的块将被发送到最右边的方法 <code>bar</code>。这是因为花括号具有更高的优先级。思考这个程序...</p>
<div class="code-file clearfix"><span>precedence.rb</span></div>

<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">foo</span><span class="hljs-params">( b )</span></span>
  puts(<span class="hljs-string">"---in foo---"</span>)
  a = <span class="hljs-string">'foo'</span>
  <span class="hljs-keyword">if</span> block_given?
    puts( <span class="hljs-string">"(Block passed to foo)"</span> )
    <span class="hljs-keyword">yield</span>( a )
  <span class="hljs-keyword">else</span>
    puts( <span class="hljs-string">"(no block passed to foo)"</span> )
  <span class="hljs-keyword">end</span>
  puts( <span class="hljs-string">"in foo, arg b = <span class="hljs-subst">#{b}</span>"</span> )
  <span class="hljs-keyword">return</span> <span class="hljs-string">"returned by "</span> &lt;&lt; a
<span class="hljs-keyword">end</span>

<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">bar</span></span>
  puts(<span class="hljs-string">"---in bar---"</span>)
  a = <span class="hljs-string">'bar'</span>
  <span class="hljs-keyword">if</span> block_given?
    puts( <span class="hljs-string">"(Block passed to bar)"</span> )
    <span class="hljs-keyword">yield</span>( a )
  <span class="hljs-keyword">else</span>
    puts( <span class="hljs-string">"(no block passed to bar)"</span> )
  <span class="hljs-keyword">end</span>
  <span class="hljs-keyword">return</span> <span class="hljs-string">"returned by "</span> &lt;&lt; a
<span class="hljs-keyword">end</span>

foo bar <span class="hljs-keyword">do</span> <span class="hljs-params">|s|</span> puts( s ) <span class="hljs-keyword">end</span>  <span class="hljs-comment"># 1) do..end block</span>

foo bar{ <span class="hljs-params">|s|</span> puts(s) }        <span class="hljs-comment"># 2) {..} block</span></code></pre><p>这里 <code>do..end</code> 块的优先级较低，方法 <code>foo</code> 优先。这意味着 <code>bar</code> 和 <code>do..end</code> 块都传递给 <code>foo</code>。因此，这两个表达式是等价的：</p>
<pre><code>foo bar <span class="hljs-built_in">do</span> |<span class="hljs-type">s</span>| <span class="hljs-type">puts</span>( s ) <span class="hljs-keyword">end</span>
foo( bar ) <span class="hljs-built_in">do</span> |<span class="hljs-type">s</span>| <span class="hljs-type">puts</span>( s ) <span class="hljs-keyword">end</span></code></pre><p>另一方面，花括号块具有更高的优先级，因此它尝试立即执行并传递给第一个可能的接收方法 <code>(bar)</code>。然后将结果（即 <code>bar</code> 返回的值）作为参数传递给 <code>foo</code>；但这一次，<code>foo</code> 本身并没有收到块。因此，以下两个表达式是等效的：</p>
<pre><code>foo bar{ |<span class="hljs-type">s</span>| <span class="hljs-type">puts</span>(s) }
foo( bar{ |<span class="hljs-type">s</span>| <span class="hljs-type">puts</span>(s) } )</code></pre><p>如果你对这一切感到困惑，不要难过因为实际上并不是你一个人感到困惑！Ruby 块的行为远非透明的。潜在的歧义是由于在 Ruby 中参数列表周围的括号是可选的。从上面给出的替代版本中可以看出，当使用括号时，模糊性消失了。</p>
<div class="note">
    <p class="h4"><b>提示...</b></p>

<p>一个方法可以使用 <code>block_given?</code> 方法测试它是否已经收到一个块。你可以在 <strong>precedence.rb</strong> 程序中找到相关示例。</p>
</div>

<h3 id="-">块作为迭代器</h3>
<p>如前所述，Rub y中块的主要用途之一是提供可以传递范围或项列表的迭代器。许多标准类（如 Integer 和 Array）都有方法可以提供块来迭代元素。例如：</p>
<pre><code><span class="hljs-number">3.</span>times{ |i| puts( i ) }

[<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>].each{|i| puts(i) }</code></pre><p>当然，你可以创建自己的迭代器方法，以便为块提供一系列值。在 <strong>iterate1.rb</strong> 程序中，我定义了一个简单的 <code>timesRepeat</code> 方法以执行指定次数的块代码。这类似 Integer 类的 <code>times</code> 方法，除了它从索引 1 而不是索引 0 开始的事实（这里显示变量 <code>i</code> 是正为了证明这一事实）：</p>
<div class="code-file clearfix"><span>iterate1.rb</span></div>

<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">timesRepeat</span><span class="hljs-params">( aNum )</span></span>
  <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-number">1</span>..aNum <span class="hljs-keyword">do</span>
    <span class="hljs-keyword">yield</span> i
  <span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span></code></pre><p>以下是如何调用此方法的示例：</p>
<pre><code>timesRepeat( <span class="hljs-number">3</span> ){ |<span class="hljs-type">i</span>| <span class="hljs-type">puts</span>(<span class="hljs-string">"[#{i}] hello world"</span>) }</code></pre><p>我还创建了一个 <code>timesRepeat2</code> 方法来迭代数组：</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">timesRepeat2</span><span class="hljs-params">( aNum, anArray )</span></span>
  anArray.each{ <span class="hljs-params">|anitem|</span>
    <span class="hljs-keyword">yield</span>( anitem )
  }
<span class="hljs-keyword">end</span></code></pre><p>这可以通过以下方式调用：</p>
<pre><code>timesRepeat2( <span class="hljs-number">3</span>, [<span class="hljs-string">"hello"</span>,<span class="hljs-string">"good day"</span>,<span class="hljs-string">"how do you do"</span>] ){ |<span class="hljs-type">x</span>| <span class="hljs-type">puts</span>(x) }</code></pre><p>事实上，如果一个对象本身包含它自己的迭代器方法，那么它将更好（面向对象的灵魂更真实）。我在下一个示例中实现了这一点。在这里，我创建了 MyArray，作为 Array 的子类：</p>
<div class="code-file clearfix"><span>iterate2.rb</span></div>

<pre><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyArray</span> &lt; Array</span></code></pre><p>在创建新的 MyArray 对象时，它使用数组初始化：</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">initialize</span><span class="hljs-params">( anArray )</span></span>
  <span class="hljs-keyword">super</span>( anArray )
<span class="hljs-keyword">end</span></code></pre><p>它向上依赖于它自己的（<em>self</em>）<code>each</code> 方法，它由它的祖先 Array 提供，以迭代数组中的所有元素，并使用 Integer 的 times 方法执行此操作一定次数。这是完整的类定义：</p>
<pre><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyArray</span> &lt; Array</span>
  <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">initialize</span><span class="hljs-params">( anArray )</span></span>
    <span class="hljs-keyword">super</span>( anArray )
  <span class="hljs-keyword">end</span>

  <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">timesRepeat</span><span class="hljs-params">( aNum )</span></span>
    aNum.times{ <span class="hljs-comment"># start block 1...</span>
      <span class="hljs-params">| num |</span>
      <span class="hljs-keyword">self</span>.each{ <span class="hljs-comment"># start block 2...</span>
        <span class="hljs-params">| anitem |</span>
        <span class="hljs-keyword">yield</span>( <span class="hljs-string">"[<span class="hljs-subst">#{num}</span>] :: '<span class="hljs-subst">#{anitem}</span>'"</span> )
      } <span class="hljs-comment"># ...end block 2</span>
    } <span class="hljs-comment"># ...end block 1</span>
  <span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span></code></pre><p>请注意，由于我使用了两个迭代器（<code>aNum.times</code> 和 <code>self.each</code>），因此 <code>timesRepeat</code> 方法包含两个嵌套块。这是一个如何使用它的示例...</p>
<pre><code>numarr = MyArray.new( [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>] )
numarr.timesRepeat( <span class="hljs-number">2</span> ){ |x| puts(x) }</code></pre><p>这将输出以下内容：</p>
<pre><code>[<span class="hljs-number">0</span>] :: <span class="hljs-string">'1'</span>
[<span class="hljs-number">0</span>] :: <span class="hljs-string">'2'</span>
[<span class="hljs-number">0</span>] :: <span class="hljs-string">'3'</span>
[<span class="hljs-number">1</span>] :: <span class="hljs-string">'1'</span>
[<span class="hljs-number">1</span>] :: <span class="hljs-string">'2'</span>
[<span class="hljs-number">1</span>] :: <span class="hljs-string">'3'</span></code></pre><p>在 <strong>iterate3.rb</strong> 中，我自己设置了为包含任意数量的子数组的数组定义迭代器的问题，其中每个子数组具有相同数量的项。换句话说，它像一个具有固定行数和固定列数的表或矩阵。例如，这里是一个具有三个“行”（rows，子数组）和四个“列”（columns，元素）的多维数组：</p>
<div class="code-file clearfix"><span>iterate3.rb</span></div>

<pre><code>multiarr =
[    [<span class="hljs-string">'one'</span>,<span class="hljs-string">'two'</span>,<span class="hljs-string">'three'</span>,<span class="hljs-string">'four'</span>],
    [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span> ],
    [<span class="hljs-symbol">:a</span>, <span class="hljs-symbol">:b</span>, <span class="hljs-symbol">:c</span>, <span class="hljs-symbol">:d</span> ]
]</code></pre><p>我已经尝试了三个替代版本。第一个版本受到限制，只能使用在预定义数量（这里是索引 [0] 和 [1]）的&quot;行数&quot;（rows）中：</p>
<pre><code>multiarr[0].length.times{|i|
  puts(multiarr[<span class="hljs-string">0</span>][<span class="hljs-symbol">i</span>], multiarr[<span class="hljs-string">1</span>][<span class="hljs-symbol">i</span>])
}</code></pre><p>第二个版本通过迭代 <code>multiarr</code> 的每个元素（或&#39;行&#39;，row）然后通过获取行长度并使用 Integer 的 <code>times</code> 方法和该值迭代该行中的每个元素来绕过此限制：</p>
<pre><code>multiarr.each{ |<span class="hljs-type">arr</span>|
  <span class="hljs-type">multiarr</span>[<span class="hljs-number">0</span>].length.times{|<span class="hljs-type">i</span>|
    <span class="hljs-type">puts</span>(arr[i])
  }
}</code></pre><p>第三个版本反转这些操作：外部块沿着行 0 的长度迭代，内部块获得每行中索引 <code>i</code> 的元素：</p>
<pre><code>multiarr[<span class="hljs-number">0</span>].length.times{|<span class="hljs-type">i</span>|
  <span class="hljs-type">multiarr</span>.each{ |<span class="hljs-type">arr</span>|
    <span class="hljs-type">puts</span>(arr[i])
  }
}</code></pre><p>虽然版本 2 和版本 3 以类似的方式工作，但你会发现它们以不同的顺序迭代这些元素项目。运行该程序以验证。你可以尝试创建自己的 Array 子类并添加像这样的迭代器方法 - 一个按顺序迭代行的方法（如上面的版本 2）和一个按顺序遍历列的方法（如版本 3）。</p>
<h2 id="-">深入探索</h2>
<h3 id="-">从方法中返回块</h3>
<p>早些时候，我解释过 Ruby 中的块可能视为“闭包”（closures）。闭包可以说是封闭声明它的“环境”（environment）。或者，换句话说，它将局部变量的值从其原始作用域带入不同的作用域。我之前给出的示例显示了名为 <code>ablock</code> 的块如何捕获局部变量 <code>x</code> 的值...</p>
<div class="code-file clearfix"><span>block_closure.rb</span></div>

<pre><code><span class="hljs-attr">x</span> = <span class="hljs-string">"hello world"</span>
<span class="hljs-attr">ablock</span> = Proc.new { puts( x ) }</code></pre><p>...然后它就能够将该变量“携带”到不同的作用域内。例如，这里将块传递给 <code>aMethod</code>。当在该方法内部调用 <code>ablock</code> 时，它运行代码 <code>puts(x)</code>。这里显示，&quot;hello world&quot; 而不是 &quot;goodbye&quot;...</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">aMethod</span><span class="hljs-params">( aBlockArg )</span></span>
  x = <span class="hljs-string">"goodbye"</span>
  aBlockArg.call <span class="hljs-comment">#&lt;= displays "hello world"</span>
<span class="hljs-keyword">end</span></code></pre><p>在这个特定的例子中，这种行为似乎对好奇心没有太大吸引力。实际上，可以更具创造性地使用块/闭包。</p>
<p>例如，你可以<em>在方法内</em>创建一个块并将该块返回给调用代码，而不是创建一个块并将其发送到方法。如果创建块的方法碰巧接收参数，则可以使用该参数初始化块。</p>
<p>这为我们提供了一种从同一“块模板”（block template）创建多个块的简单方法，每个块的实例都使用不同的数据进行初始化。例如，在这里我创建了两个块，分配给变量 <code>salesTax</code> 和 <code>vat</code>，每个块根据不同的值（0.10）和（0.175）计算结果：</p>
<div class="code-file clearfix"><span>block_closure2.rb</span></div>

<pre><code>def calcTax( taxRate )
  <span class="hljs-keyword">return</span> lambda{
    |subtotal|
    subtotal * taxRate
  }
end

salesTax = calcTax( <span class="hljs-number">0.10</span> )
vat = calcTax( <span class="hljs-number">0.175</span> )

<span class="hljs-keyword">print</span>( <span class="hljs-string">"Tax due on book = "</span>)
<span class="hljs-keyword">print</span>( salesTax.<span class="hljs-keyword">call</span>( <span class="hljs-number">10</span> ) )  #&lt;= <span class="hljs-keyword">print</span><span class="hljs-variable">s:</span> <span class="hljs-number">1.0</span>

<span class="hljs-keyword">print</span>( <span class="hljs-string">"\nVat due on DVD = "</span>)
<span class="hljs-keyword">print</span>( vat.<span class="hljs-keyword">call</span>( <span class="hljs-number">10</span> ) )       #&lt;= <span class="hljs-keyword">print</span><span class="hljs-variable">s:</span> <span class="hljs-number">1.75</span></code></pre><h3 id="-">块与实例变量</h3>
<p>块的一个不太明显的特性是它们使用变量的方式。如果一个块可能真的被视为匿名函数或方法，那么从逻辑上讲，它应该能够：1）包含它自己的局部变量；2）能够访问该块所属的对象的实例变量。</p>
<p>我们先来看实例变量（instance variables）。加载 <strong>closures1.rb</strong> 程序。这提供了块等同于闭包的另一个例子 - 通过捕获创建它的作用域中的局部变量的值。这里我使用 <code>lambda</code> 方法创建了块：</p>
<div class="code-file clearfix"><span>closures1.rb</span></div>

<pre><code>aClos = lambda{
  @hello &lt;&lt; <span class="hljs-string">" yikes!"</span>
}</code></pre><p>这个块将一个字符串 &quot;yikes!&quot; 附加到一个实例变量 <code>@hello</code>。请注意，在这个过程中，之前没有为 <code>@hello</code> 分配任何值。</p>
<p>但是，我创建了一个单独的方法 <code>aFunc</code>，它为一个名为 <code>@hello</code> 的变量赋值：</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">aFunc</span><span class="hljs-params">( aClosure )</span></span>
  @hello = <span class="hljs-string">"hello world"</span>
  aClosure.call
<span class="hljs-keyword">end</span></code></pre><p>当我将块传递给该方法（<code>aClosure</code> 参数）时，<code>aFunc</code> 方法将引入 <code>@hello</code> 。我现在可以使用 <code>call</code> 方法执行块内代码。当然 <code>@hello</code> 变量包含字符串 &quot;hello world&quot;。通过调用块也可以使用方法之外相同的变量。实际上，现在，通过反复调用块，我最终会反复追加字符串 &quot;yikes!&quot; 到 <code>@hello</code>：</p>
<pre><code>aFunc(aClos)  <span class="hljs-meta">#&lt;= @hello = “hello world yikes!”</span>
aClos.<span class="hljs-built_in">call</span>    <span class="hljs-meta">#&lt;= @hello = “hello world yikes! yikes!”</span>
aClos.<span class="hljs-built_in">call</span>    <span class="hljs-meta">#&lt;= @hello = “hello world yikes! yikes! yikes!”</span>
aClos.<span class="hljs-built_in">call</span>    <span class="hljs-meta"># ...and so on</span>
aClos.<span class="hljs-built_in">call</span></code></pre><p>如果你认为这并不是太令人惊讶。毕竟，<code>@hello</code> 是一个实例变量，因此它存在于一个对象的作用域内。当我们运行 Ruby 程序时，会自动创建一个名为 <code>main</code> 的对象。所以我们应该期望在该对象（我们的程序）中创建的任何实例变量可用于其中的所有内容。</p>
<p>现在出现的问题是：如果要将块发送到某个<em>其它</em>对象的方法会发生什么？如果该对象有自己的实例变量 <code>@hello</code>，那么该块会使用哪个变量 - 来自创建块的作用域内的 <code>@hello</code>，还是来自调用该块的对象作用域内的 <code>@hello</code>？让我们尝试一下。我们将使用与以前相同的块，除了这次它将显示有关块所属对象和 <code>@hello</code> 值的一些信息：</p>
<pre><code>aClos = lambda{
  @hello &lt;&lt; <span class="hljs-string">" yikes!"</span>
  puts(<span class="hljs-string">"in <span class="hljs-subst">#{<span class="hljs-keyword">self</span>}</span> object of class <span class="hljs-subst">#{<span class="hljs-keyword">self</span>.<span class="hljs-keyword">class</span>}</span>, @hello = <span class="hljs-subst">#{@hello}</span>"</span>)
}</code></pre><p>现在从新类（X）创建一个新对象，并为它提供一个接收我们的块 <code>b</code> 的方法，并调用该块：</p>
<pre><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">X</span></span>
  <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">y</span><span class="hljs-params">( b )</span></span>
    @hello = <span class="hljs-string">"I say, I say, I say!!!"</span>
    puts( <span class="hljs-string">" [In X.y]"</span> )
    puts(<span class="hljs-string">"in <span class="hljs-subst">#{<span class="hljs-keyword">self</span>}</span> object of class <span class="hljs-subst">#{<span class="hljs-keyword">self</span>.<span class="hljs-keyword">class</span>}</span>, @hello = <span class="hljs-subst">#{@hello}</span>"</span>)
    puts( <span class="hljs-string">" [In X.y] when block is called..."</span> )
    b.call
  <span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>

x = X.new</code></pre><p>要测试它，只需将块 <code>aClos</code> 传递给 <code>x</code> 的 <code>y</code> 方法：</p>
<pre><code><span class="hljs-symbol">x</span>.<span class="hljs-symbol">y</span>( aClos )</code></pre><p>这就是显示的内容：</p>
<pre><code>[In X.y]
<span class="hljs-keyword">in</span> #&lt;X:<span class="hljs-number">0x32a6e64</span>&gt; <span class="hljs-keyword">object</span> of <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">X</span>, <span class="hljs-type">@hello = I say</span>, <span class="hljs-type">I say</span>, <span class="hljs-type">I say!!!</span></span>
[In X.y] <span class="hljs-keyword">when</span> block <span class="hljs-keyword">is</span> called...
<span class="hljs-keyword">in</span> main <span class="hljs-keyword">object</span> of <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Object</span>, <span class="hljs-type">@hello = hello world yikes! yikes! yikes! yikes! yikes! yikes!</span></span></code></pre><p>因此，很明显，块在创建它的对象（main）的作用域内执行，并保留该对象的实例变量，即使在调用块的对象的作用域内有一个具有相同名称和不同值的实例变量。</p>
<h3 id="-">块与局部变量</h3>
<p>现在让我们看看块/闭包（block/closure）如何处理局部变量（local variables）。加载 <strong>closures2.rb</strong> 程序。首先，我声明一个变量 <code>x</code>，它对程序本身的上下文来说是局部的：</p>
<div class="code-file clearfix"><span>closures2.rb</span></div>

<pre><code><span class="hljs-attr">x</span> = <span class="hljs-number">3000</span></code></pre><p>第一个块/闭包称为 <code>c1</code>。每次我调用这个块时，它会获取块本身外部定义的 <code>x</code> 值（3000）并返回 <code>x+100</code>：</p>
<pre><code>c1 = lambda{
  <span class="hljs-keyword">return</span> x + <span class="hljs-number">100</span>
}</code></pre><p>这个块没有块参数（也就是说，竖条之间没有&#39;块局部&#39;（block local）变量）所以当用变量 <code>someval</code> 调用它时，该变量被丢弃，未使用。换句话说，<code>c1.call(someval)</code> 与 <code>c1.call()</code> 具有相同的效果。所以当你调用块 <code>c1</code> 时，它返回 <code>x+100</code>（即 3100），然后将该值赋给 <code>someval</code>。</p>
<pre><code>someval=<span class="hljs-number">1000</span>
someval=c<span class="hljs-number">1.</span><span class="hljs-keyword">call</span><span class="hljs-comment">(someval)</span>; puts<span class="hljs-comment">(someval)</span> <span class="hljs-attr">#&lt;= someval is now 3100</span>
someval=c<span class="hljs-number">1.</span><span class="hljs-keyword">call</span><span class="hljs-comment">(someval)</span>; puts<span class="hljs-comment">(someval)</span> <span class="hljs-attr">#&lt;= someval is now 3100</span></code></pre><div class="note">

<p><strong>注意：</strong>如上所示，你可以将调用放在块中并将其传递给 Integer 的 <code>times</code> 方法，而不是重复调用 <code>c1</code>，如下所示：</p>
<pre><code><span class="hljs-number">2.</span>times{ someval=c<span class="hljs-number">1.</span><span class="hljs-keyword">call</span><span class="hljs-comment">(someval)</span>; puts<span class="hljs-comment">(someval)</span> }</code></pre><p>但是，因为它可能很难在只有一个块（例如这里的 <code>c1</code> 块）的情况下工作，以至于我故意避免使用比这个程序中更多本应该必要的块！</p>
</div>

<p>第二个块名为 <code>c2</code>。这声明了一个&#39;块参数&#39;（block parameter），<code>z</code>。这也返回一个值：</p>
<pre><code>c2 = lambda{
  |z|
  <span class="hljs-keyword">return</span> z + <span class="hljs-number">100</span>
}</code></pre><p>但是，这次返回值可以重复使用，因为块参数就像一个方法的传入参数 - 所以当 <code>someval</code> 的值在被赋值为 <code>c2</code> 的返回值之后被更改时，这个更改的值随后作为参数传入：</p>
<pre><code>someval=<span class="hljs-number">1000</span>
someval=c<span class="hljs-number">2.</span><span class="hljs-keyword">call</span><span class="hljs-comment">(someval)</span>; puts<span class="hljs-comment">(someval)</span> <span class="hljs-attr">#&lt;= someval is now 1100</span>
someval=c<span class="hljs-number">2.</span><span class="hljs-keyword">call</span><span class="hljs-comment">(someval)</span>; puts<span class="hljs-comment">(someval)</span> <span class="hljs-attr">#&lt;= someval is now 1200</span></code></pre><p>乍一看，第三个块 <code>c3</code> 与第二个块 <code>c2</code> 几乎相同。实际上，唯一的区别是它的块参数被称为 <code>x</code> 而不是 <code>z</code>：</p>
<pre><code>c3 = lambda{
  |<span class="hljs-symbol">x</span>|
  <span class="hljs-keywords">return</span> <span class="hljs-symbol">x</span> + <span class="hljs-number">100</span>
}</code></pre><p>块参数的名称对返回值没有影响。和以前一样，<code>someval</code> 首先被赋值 1100（即，它的原始值 1000，加上块中添加的 100）然后，当第二次调用块时，<code>someval</code> 被赋值为 1200（其先前的值 1100，加上在块内分配的 100）。</p>
<p>但现在看一下局部变量 <code>x</code> 的值会发生什么。在该单元的顶部分配了 3000。只需给块参数指定相同的名称 <code>x</code>，我们就改变了局部变量 <code>x</code> 的值。它现在具有值 1100，即块参数 <code>x</code> 在调用 <code>c3</code> 块时最后具有的值：</p>
<pre><code>x = 3000

c3 = lambda{
  |x|
  return x + 100
}

someval=1000
someval=c3.call(someval); puts(someval)
someval=c3.call(someval); puts(someval)
puts( x )  <span class="hljs-comment">#&lt;= x is now 1100</span></code></pre><p>顺便提一下，即使块局部变量和块参数可以影响块外部的类似命名的局部变量，块变量本身也不会在块之外存在。你可以使用 <code>defined?</code> 关键字对此进行验证，以尝试显示变量的类型（如果确实已定义）：</p>
<pre><code>print(<span class="hljs-string">"x=[<span class="hljs-subst">#{<span class="hljs-keyword">defined</span>?(x)}</span>],z=[<span class="hljs-subst">#{<span class="hljs-keyword">defined</span>?(z)}</span>]"</span>)</code></pre><p>Ruby 的创造者 Matz，他将块内局部变量的作用域描述为“抱歉的”（regrettable）。特别是，他认为在一个块中使局部变量对包含该块的方法不可见是错误的。有关此示例，请参阅 <strong>local_var_scope.rb</strong>：</p>
<div class="code-file clearfix"><span>local_var_scope.rb</span></div>

<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">foo</span></span>
  a = <span class="hljs-number">100</span>
  [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>].each <span class="hljs-keyword">do</span> <span class="hljs-params">|b|</span>
    c = b
    a = b
    print(<span class="hljs-string">"a=<span class="hljs-subst">#{a}</span>, b=<span class="hljs-subst">#{b}</span>, c=<span class="hljs-subst">#{c}</span>\n"</span>)
  <span class="hljs-keyword">end</span>
  print(<span class="hljs-string">"Outside block: a=<span class="hljs-subst">#{a}</span>\n"</span>) <span class="hljs-comment"># Can't print #{b} and #{c} here!!!</span>
<span class="hljs-keyword">end</span></code></pre><p>这里，块参数 <code>b</code> 和块局部变量 <code>c</code> 只有在块本身内部时才可见。该块可以访问这些变量并作用于变量 <code>a</code>（<code>foo</code> 方法的局部）。但是，在块之外，<code>b</code> 和 <code>c</code> 是不可访问的，只有<code>a</code> 是可见的。</p>
<p>只是为了增加迷惑性，块局部变量 <code>c</code> 和块参数 <code>b</code> 在上面的示例中都不能在块外部访问，但是当你用一个<code>for</code> 块迭代时可以访问它们，如下例所示：</p>
<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">foo2</span></span>
  a = <span class="hljs-number">100</span>
  <span class="hljs-keyword">for</span> b <span class="hljs-keyword">in</span> [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>] <span class="hljs-keyword">do</span>
    c = b
    a = b
    print(<span class="hljs-string">"a=<span class="hljs-subst">#{a}</span>, b=<span class="hljs-subst">#{b}</span>, c=<span class="hljs-subst">#{c}</span>\n"</span>)
  <span class="hljs-keyword">end</span>
  print(<span class="hljs-string">"Outside block: a=<span class="hljs-subst">#{a}</span>, b=<span class="hljs-subst">#{b}</span>, c=<span class="hljs-subst">#{b}</span>\n"</span>)
<span class="hljs-keyword">end</span></code></pre><p>在 Ruby 的未来版本中，在块内赋值的局部变量（与 <code>c</code> 一样）也将是块外部方法（例如 <code>foo</code>）的局部变量。形式上块参数（如 <code>b</code>）将是块的局部变量。</p>
